const fs = require('fs').promises;
const path = require('path');
const { app } = require('electron');

class FileManager {
  constructor() {
    this.basePath = path.join(app.getPath('userData'), 'uploads');
    this.init();
  }

  async init() {
    try {
      // 创建上传目录
      await fs.mkdir(this.basePath, { recursive: true });
      
      // 创建各类型子目录
      const subdirs = ['journals', 'conferences', 'patents', 'software', 'competitions', 'projects'];
      for (const subdir of subdirs) {
        await fs.mkdir(path.join(this.basePath, subdir), { recursive: true });
      }
      
      console.log('文件存储目录初始化成功:', this.basePath);
    } catch (error) {
      console.error('文件存储目录初始化失败:', error);
    }
  }

  // 检查文件是否存在，如果存在则生成新的文件名（添加序号）
  async getAvailableFileName(recordDir, originalName) {
    const ext = path.extname(originalName);
    const name = path.basename(originalName, ext);
    let fileName = originalName;
    let counter = 1;

    // 检查文件是否已存在，如果存在则添加序号
    while (true) {
      const filePath = path.join(recordDir, fileName);
      try {
        await fs.access(filePath);
        // 文件存在，生成新文件名
        fileName = `${name}_${counter}${ext}`;
        counter++;
      } catch {
        // 文件不存在，可以使用这个文件名
        break;
      }
    }

    return fileName;
  }

  // 保存文件（使用原始文件名，如果重名则添加序号）
  async saveFile(file, userId, recordType, recordId, uploadAreaKey) {
    try {
      // 创建记录目录：basePath/userId/recordType/recordId
      const recordDir = path.join(this.basePath, userId.toString(), recordType, recordId.toString());
      await fs.mkdir(recordDir, { recursive: true });
      
      // 获取可用的文件名（如果重名则添加序号）
      const fileName = await this.getAvailableFileName(recordDir, file.name);
      const filePath = path.join(recordDir, fileName);
      
      // 保存文件
      await fs.writeFile(filePath, file.buffer || file.data);
      
      // 只返回文件名，不返回完整路径（数据库只存储文件名）
      return {
        fileName: fileName || '',
        originalName: file.name || '',
        fileSize: file.size || 0,
        fileType: file.type || ''
      };
    } catch (error) {
      console.error('文件保存失败:', error);
      throw error;
    }
  }

  // 移动文件（从临时目录移动到记录目录）
  async moveFile(oldFilePath, userId, newRecordType, newRecordId) {
    try {
      const oldPath = oldFilePath;
      const fileName = path.basename(oldPath);
      const newRecordDir = path.join(this.basePath, userId.toString(), newRecordType, newRecordId.toString());
      await fs.mkdir(newRecordDir, { recursive: true });
      const newPath = path.join(newRecordDir, fileName);
      
      await fs.rename(oldPath, newPath);
      
      // 只返回文件名，不返回完整路径
      return {
        fileName: fileName
      };
    } catch (error) {
      console.error('移动文件失败:', error);
      throw error;
    }
  }

  // 删除文件（根据文件名、用户ID、记录类型、记录ID）
  async deleteFile(userId, recordType, recordId, fileName) {
    try {
      const filePath = this.getFilePath(userId, recordType, recordId, fileName);
      console.log('尝试删除文件:', filePath);
      
      // 检查文件是否存在
      try {
        await fs.access(filePath);
      } catch (accessError) {
        if (accessError.code === 'ENOENT') {
          console.warn('文件不存在，跳过删除:', filePath);
          return; // 文件不存在，不算错误
        }
        throw accessError;
      }
      
      // 删除文件
      await fs.unlink(filePath);
      console.log('文件删除成功:', filePath);
    } catch (error) {
      console.error('文件删除失败:', error);
      throw error;
    }
  }

  // 删除记录的所有文件
  async deleteRecordFiles(userId, recordType, recordId) {
    try {
      const recordDir = path.join(this.basePath, userId.toString(), recordType, recordId.toString());
      
      // 检查目录是否存在
      try {
        await fs.access(recordDir);
      } catch {
        // 目录不存在，直接返回（不算错误）
        console.log('记录文件目录不存在，跳过删除:', recordDir);
        return;
      }
      
      // 删除目录及其所有内容
      // 使用 rmdir with recursive: true (Node.js 12.10.0+)
      await fs.rmdir(recordDir, { recursive: true });
      
      console.log('记录文件删除成功:', recordDir);
    } catch (error) {
      // 如果目录不存在或其他错误，记录但不抛出异常（允许继续删除数据库记录）
      if (error.code === 'ENOENT') {
        console.log('记录文件目录不存在，跳过删除:', recordDir);
        return;
      }
      console.error('记录文件删除失败:', error);
      throw error;
    }
  }

  // 根据文件名、用户ID、记录类型、记录ID获取文件完整路径
  getFilePath(userId, recordType, recordId, fileName) {
    return path.join(this.basePath, userId.toString(), recordType, recordId.toString(), fileName);
  }

  // 检查文件是否存在
  async fileExists(userId, recordType, recordId, fileName) {
    try {
      const filePath = this.getFilePath(userId, recordType, recordId, fileName);
      await fs.access(filePath);
      return true;
    } catch {
      return false;
    }
  }
}

module.exports = FileManager;